home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / dev / lang / SmallEiffel.lha / SmallEiffel / bin_c / compile_to_jvm8.c < prev    next >
C/C++ Source or Header  |  1998-12-22  |  18KB  |  918 lines
  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.79)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "compile_to_jvm.h"
  9.  
  10.  
  11. void r212with_capacity(T212* C,T2 a1){
  12. /*[IF*/
  13. if(((C)->_capacity/*8*/)<(a1)){
  14. C->_storage=calloc(a1,sizeof(T0*));
  15. C->_capacity=a1;
  16. }
  17. /*FI]*/
  18. C->_upper=-(1);
  19. }
  20.  
  21.  
  22. T0* r212twin(T212* C){
  23. T0* R=NULL;
  24. R=malloc(sizeof(*C));
  25. *((T212*)R)=M212;
  26. r212copy(((T212*)R),((T0*)C));
  27. return R;
  28. }
  29. /*No:FIXED_ARRAY[MANIFEST_STRING].clear_all*/
  30.  
  31.  
  32. void r212add_last(T212* C,T0* a1){
  33. T2 _new_capacity=0;
  34. /*[IF*/
  35. if((((C)->_upper/*12*/)+(1))<=(((C)->_capacity/*8*/)-(1))){
  36. C->_upper=((C)->_upper/*12*/)+(1);
  37. }
  38.  else if(((C)->_capacity/*8*/)==(0)){
  39. C->_storage=calloc(2,sizeof(T0*));
  40. C->_capacity=2;
  41. C->_upper=0;
  42. }
  43. else{
  44. _new_capacity=(2)*((C)->_capacity/*8*/);
  45. C->_storage=r213realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  46. C->_capacity=_new_capacity;
  47. C->_upper=((C)->_upper/*12*/)+(1);
  48. }
  49. /*FI]*/
  50. /*[IRF3.5put*/((C)->_storage/*4*/)[(C)->_upper/*12*/]=(a1);
  51. /*]*/
  52. }
  53. /*No:FIXED_ARRAY[MANIFEST_STRING].item*/
  54. /*No:FIXED_ARRAY[MANIFEST_STRING].set_all_with*/
  55. /*No:FIXED_ARRAY[MANIFEST_STRING].count*/
  56.  
  57.  
  58. void r212resize(T212* C,T2 a1){
  59. T0* _elt_default=NULL;
  60. T2 _i=0;
  61. T2 _new_capacity=0;
  62. /*[IF*/
  63. if((a1)<=(/*(IRF4.6count*/((C)->_upper/*12*/)+(1)/*)*/)){
  64. C->_upper=(a1)-(1);
  65. }
  66. else{
  67. _new_capacity=a1;
  68. /*[IF*/
  69. if(((C)->_capacity/*8*/)<(_new_capacity)){
  70. /*[IF*/
  71. if(((C)->_capacity/*8*/)==(0)){
  72. C->_storage=calloc(_new_capacity,sizeof(T0*));
  73. }
  74. else{
  75. C->_storage=r213realloc((C)->_storage/*4*/,(C)->_capacity/*8*/,_new_capacity);
  76. }
  77. /*FI]*/
  78. C->_capacity=_new_capacity;
  79. }
  80. /*FI]*/
  81. _new_capacity=(C)->_upper/*12*/;
  82. C->_upper=(a1)-(1);
  83. _i=(C)->_upper/*12*/;
  84. while (!((_i)==(_new_capacity))) {
  85. /*[IRF3.5put*/((C)->_storage/*4*/)[_i]=(_elt_default);
  86. /*]*/
  87. _i=(_i)-(1);
  88. }
  89. }
  90. /*FI]*/
  91. }
  92.  
  93.  
  94. void r212make(T212* C,T2 a1){
  95. /*[IF*/
  96. if((a1)==(0)){
  97. C->_upper=-(1);
  98. }
  99.  else if(((C)->_capacity/*8*/)==(0)){
  100. C->_storage=calloc(a1,sizeof(T0*));
  101. C->_capacity=a1;
  102. C->_upper=(a1)-(1);
  103. }
  104.  else if(((C)->_capacity/*8*/)<(a1)){
  105. C->_storage=calloc(a1,sizeof(T0*));
  106. C->_capacity=a1;
  107. C->_upper=(a1)-(1);
  108. }
  109. else{
  110. C->_upper=(a1)-(1);
  111. /*[IRF3.6clear_all*/{T212* C1=C;
  112. T0* __value=NULL;
  113. /*[IRF3.6set_all_with*/{T212* C2=C1;
  114. T0* c1=__value;
  115. r213set_all_with((C2)->_storage/*4*/,c1,(C2)->_upper/*12*/);
  116. }/*]*/
  117. }/*]*/
  118. }
  119. /*FI]*/
  120. }
  121. /*No:FIXED_ARRAY[MANIFEST_STRING].upper*/
  122.  
  123.  
  124. void r212copy(T212* C,T0* a1){
  125. T2 _new_capacity=0;
  126. T2 _other_upper=0;
  127. _other_upper=(((T212*)a1))->_upper/*12*/;
  128. /*[IF*/
  129. if((_other_upper)>=(0)){
  130. _new_capacity=(_other_upper)+(1);
  131. /*[IF*/
  132. if(((C)->_capacity/*8*/)<(_new_capacity)){
  133. C->_capacity=_new_capacity;
  134. C->_storage=calloc(_new_capacity,sizeof(T0*));
  135. }
  136.  else if(((C)->_capacity/*8*/)>(0)){
  137. r213clear_all((C)->_storage/*4*/,((C)->_capacity/*8*/)-(1));
  138. }
  139. /*FI]*/
  140. r213copy_from((C)->_storage/*4*/,(((T212*)a1))->_storage/*4*/,_other_upper);
  141. }
  142.  else if(((C)->_capacity/*8*/)>(0)){
  143. r213clear_all((C)->_storage/*4*/,((C)->_capacity/*8*/)-(1));
  144. }
  145. /*FI]*/
  146. C->_upper=_other_upper;
  147. }
  148. /*No:FIXED_ARRAY[MANIFEST_STRING].capacity*/
  149. /*No:FIXED_ARRAY[MANIFEST_STRING].put*/
  150. /*No:FIXED_ARRAY[MANIFEST_STRING].storage*/
  151. /*No:ARRAY[BOOLEAN].clear_all*/
  152.  
  153.  
  154. void r370force(T370* C,T6 a1,T2 a2){
  155. /*[IF*/
  156. if(((C)->_upper/*8*/)<(a2)){
  157. r370resize(C,(C)->_lower/*12*/,a2);
  158. }
  159.  else if((a2)<((C)->_lower/*12*/)){
  160. r370resize(C,a2,(C)->_upper/*8*/);
  161. }
  162. /*FI]*/
  163. /*[IRF3.6put*/{T370* C1=C;
  164. T6 b1=a1;
  165. T2 b2=a2;
  166. ((C1)->_storage/*0*/)[(b2)-((C1)->_lower/*12*/)]=(b1);
  167. }/*]*/
  168. }
  169. /*No:ARRAY[BOOLEAN].set_all_with*/
  170.  
  171.  
  172. T6 r370item(T370* C,T2 a1){
  173. T6 R=0;
  174. R=((C)->_storage/*0*/)[(a1)-((C)->_lower/*12*/)];
  175. return R;
  176. }
  177.  
  178.  
  179. T6 r370valid_index(T370* C,T2 a1){
  180. T6 R=0;
  181. R=(((C)->_lower/*12*/)<=(a1))&&((a1)<=((C)->_upper/*8*/));
  182. return R;
  183. }
  184.  
  185.  
  186. void r370set_slice_with(T370* C,T6 a1,T2 a2,T2 a3){
  187. T2 _i=0;
  188. _i=a2;
  189. while (!((_i)>(a3))) {
  190. /*[IRF3.6put*/{T370* C1=C;
  191. T6 b1=a1;
  192. T2 b2=_i;
  193. ((C1)->_storage/*0*/)[(b2)-((C1)->_lower/*12*/)]=(b1);
  194. }/*]*/
  195. _i=(_i)+(1);
  196. }
  197. }
  198. /*No:ARRAY[BOOLEAN].lower*/
  199.  
  200.  
  201. void r370resize(T370* C,T2 a1,T2 a2){
  202. T2 _intersize=0;
  203. T2 _offset=0;
  204. T2 _needed=0;
  205. _needed=((a2)-(a1))+(1);
  206. /*[IF*/
  207. if((_needed)>(0)){
  208. /*[IF*/
  209. if((_needed)>((C)->_capacity/*4*/)){
  210. /*[IF*/
  211. if(((C)->_capacity/*4*/)==(0)){
  212. C->_storage=calloc(_needed,sizeof(T6));
  213. C->_capacity=_needed;
  214. }
  215. else{
  216. C->_storage=r371realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_needed);
  217. C->_capacity=_needed;
  218. }
  219. /*FI]*/
  220. }
  221. /*FI]*/
  222. _offset=((C)->_lower/*12*/)-(a1);
  223. _intersize=((r2min(a2,(C)->_upper/*8*/))-(r2max(a1,(C)->_lower/*12*/)))+(1);
  224. /*[IF*/
  225. if((_intersize)>(0)){
  226. /*[IF*/
  227. if((_offset)==(0)){
  228. /*[IF*/
  229. if((_intersize)<(_needed)){
  230. r371clear((C)->_storage/*0*/,_intersize,(_needed)-(1));
  231. }
  232. /*FI]*/
  233. }
  234.  else if((_offset)<(0)){
  235. r371move((C)->_storage/*0*/,-(_offset),((_intersize)-(_offset))-(1),_offset);
  236. /*[IF*/
  237. if((_intersize)<(_needed)){
  238. r371clear((C)->_storage/*0*/,_intersize,(_needed)-(1));
  239. }
  240. /*FI]*/
  241. }
  242. else{
  243. r371move((C)->_storage/*0*/,0,(_intersize)-(1),_offset);
  244. r371clear((C)->_storage/*0*/,0,(_offset)-(1));
  245. /*[IF*/
  246. if(((_intersize)+(_offset))<(_needed)){
  247. r371clear((C)->_storage/*0*/,(_intersize)+(_offset),(_needed)-(1));
  248. }
  249. /*FI]*/
  250. }
  251. /*FI]*/
  252. }
  253. else{
  254. r371clear((C)->_storage/*0*/,0,(_needed)-(1));
  255. }
  256. /*FI]*/
  257. }
  258. /*FI]*/
  259. C->_lower=a1;
  260. C->_upper=a2;
  261. }
  262.  
  263.  
  264. void r370make(T370* C,T2 a1,T2 a2){
  265. T2 _needed=0;
  266. C->_lower=a1;
  267. C->_upper=a2;
  268. _needed=((a2)-(a1))+(1);
  269. /*[IF*/
  270. if((_needed)>(0)){
  271. /*[IF*/
  272. if(((C)->_capacity/*4*/)<(_needed)){
  273. C->_storage=calloc(_needed,sizeof(T6));
  274. C->_capacity=_needed;
  275. }
  276. else{
  277. /*[IRF3.6clear_all*/{T370* C1=C;
  278. T6 __value=0;
  279. /*[IRF3.6set_all_with*/{T370* C2=C1;
  280. T6 c1=__value;
  281. r371set_all_with((C2)->_storage/*0*/,c1,((C2)->_upper/*8*/)-((C2)->_lower/*12*/));
  282. }/*]*/
  283. }/*]*/
  284. }
  285. /*FI]*/
  286. }
  287. /*FI]*/
  288. }
  289. /*No:ARRAY[BOOLEAN].upper*/
  290. /*No:ARRAY[BOOLEAN].capacity*/
  291. /*No:ARRAY[BOOLEAN].put*/
  292. /*No:ARRAY[BOOLEAN].storage*/
  293.  
  294.  
  295. void r175add_last(T175* C,T2 a1){
  296. T2 _new_capacity=0;
  297. /*[IF*/
  298. if(((C)->_capacity/*4*/)<((r175count(C))+(1))){
  299. /*[IF*/
  300. if(((C)->_capacity/*4*/)==(0)){
  301. C->_capacity=16;
  302. C->_storage=calloc((C)->_capacity/*4*/,sizeof(T2));
  303. }
  304. else{
  305. _new_capacity=(2)*((C)->_capacity/*4*/);
  306. C->_storage=r49realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_new_capacity);
  307. C->_capacity=_new_capacity;
  308. }
  309. /*FI]*/
  310. }
  311. /*FI]*/
  312. C->_upper=((C)->_upper/*8*/)+(1);
  313. /*[IRF3.6put*/{T175* C1=C;
  314. T2 b1=a1;
  315. T2 b2=(C)->_upper/*8*/;
  316. ((C1)->_storage/*0*/)[(b2)-((C1)->_lower/*12*/)]=(b1);
  317. }/*]*/
  318. }
  319.  
  320.  
  321. T2 r175count(T175* C){
  322. T2 R=0;
  323. R=(((C)->_upper/*8*/)-((C)->_lower/*12*/))+(1);
  324. return R;
  325. }
  326. /*No:ARRAY[INTEGER].lower*/
  327. /*No:ARRAY[INTEGER].upper*/
  328. /*No:ARRAY[INTEGER].capacity*/
  329. /*No:ARRAY[INTEGER].put*/
  330. /*No:ARRAY[INTEGER].storage*/
  331.  
  332.  
  333. void r344with_capacity(T344* C,T2 a1){
  334. /*[IF*/
  335. if(((C)->_capacity/*4*/)<(a1)){
  336. C->_storage=calloc(a1,sizeof(T0*));
  337. C->_capacity=a1;
  338. }
  339. /*FI]*/
  340. C->_upper=-(1);
  341. }
  342.  
  343.  
  344. void r344add_last(T344* C,T0* a1){
  345. T2 _new_capacity=0;
  346. /*[IF*/
  347. if((((C)->_upper/*8*/)+(1))<=(((C)->_capacity/*4*/)-(1))){
  348. C->_upper=((C)->_upper/*8*/)+(1);
  349. }
  350.  else if(((C)->_capacity/*4*/)==(0)){
  351. C->_storage=calloc(2,sizeof(T0*));
  352. C->_capacity=2;
  353. C->_upper=0;
  354. }
  355. else{
  356. _new_capacity=(2)*((C)->_capacity/*4*/);
  357. C->_storage=r84realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_new_capacity);
  358. C->_capacity=_new_capacity;
  359. C->_upper=((C)->_upper/*8*/)+(1);
  360. }
  361. /*FI]*/
  362. /*[IRF3.5put*/((C)->_storage/*0*/)[(C)->_upper/*8*/]=(a1);
  363. /*]*/
  364. }
  365.  
  366.  
  367. void r344remove_last(T344* C){
  368. C->_upper=((C)->_upper/*8*/)-(1);
  369. }
  370. /*No:FIXED_ARRAY[PARENT].item*/
  371.  
  372.  
  373. T0* r344last(T344* C){
  374. T0* R=NULL;
  375. R=/*(IRF4.6item*/((C)->_storage/*0*/)[(C)->_upper/*8*/]/*)*/;
  376. return R;
  377. }
  378. /*No:FIXED_ARRAY[PARENT].count*/
  379. /*No:FIXED_ARRAY[PARENT].upper*/
  380. /*No:FIXED_ARRAY[PARENT].clear*/
  381.  
  382.  
  383. T6 r344empty(T344* C){
  384. T6 R=0;
  385. R=(/*(IRF4.6count*/((C)->_upper/*8*/)+(1)/*)*/)==(0);
  386. return R;
  387. }
  388. /*No:FIXED_ARRAY[PARENT].capacity*/
  389. /*No:FIXED_ARRAY[PARENT].put*/
  390. /*No:FIXED_ARRAY[PARENT].storage*/
  391.  
  392.  
  393. void r68with_capacity(T68* C,T2 a1){
  394. /*[IF*/
  395. if(((C)->_capacity/*4*/)<(a1)){
  396. C->_storage=calloc(a1,sizeof(T0*));
  397. C->_capacity=a1;
  398. }
  399. /*FI]*/
  400. C->_upper=-(1);
  401. }
  402. /*No:FIXED_ARRAY[STRING].clear_all*/
  403.  
  404.  
  405. void r68add_last(T68* C,T0* a1){
  406. T2 _new_capacity=0;
  407. /*[IF*/
  408. if((((C)->_upper/*8*/)+(1))<=(((C)->_capacity/*4*/)-(1))){
  409. C->_upper=((C)->_upper/*8*/)+(1);
  410. }
  411.  else if(((C)->_capacity/*4*/)==(0)){
  412. C->_storage=calloc(2,sizeof(T0*));
  413. C->_capacity=2;
  414. C->_upper=0;
  415. }
  416. else{
  417. _new_capacity=(2)*((C)->_capacity/*4*/);
  418. C->_storage=r69realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_new_capacity);
  419. C->_capacity=_new_capacity;
  420. C->_upper=((C)->_upper/*8*/)+(1);
  421. }
  422. /*FI]*/
  423. /*[IRF3.5put*/((C)->_storage/*0*/)[(C)->_upper/*8*/]=(a1);
  424. /*]*/
  425. }
  426. /*No:FIXED_ARRAY[STRING].item*/
  427. /*No:FIXED_ARRAY[STRING].set_all_with*/
  428.  
  429.  
  430. T6 r68valid_index(T68* C,T2 a1){
  431. T6 R=0;
  432. R=((0)<=(a1))&&((a1)<=((C)->_upper/*8*/));
  433. return R;
  434. }
  435. /*No:FIXED_ARRAY[STRING].lower*/
  436. /*No:FIXED_ARRAY[STRING].count*/
  437.  
  438.  
  439. void r68resize(T68* C,T2 a1){
  440. T0* _elt_default=NULL;
  441. T2 _i=0;
  442. T2 _new_capacity=0;
  443. /*[IF*/
  444. if((a1)<=(/*(IRF4.6count*/((C)->_upper/*8*/)+(1)/*)*/)){
  445. C->_upper=(a1)-(1);
  446. }
  447. else{
  448. _new_capacity=a1;
  449. /*[IF*/
  450. if(((C)->_capacity/*4*/)<(_new_capacity)){
  451. /*[IF*/
  452. if(((C)->_capacity/*4*/)==(0)){
  453. C->_storage=calloc(_new_capacity,sizeof(T0*));
  454. }
  455. else{
  456. C->_storage=r69realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_new_capacity);
  457. }
  458. /*FI]*/
  459. C->_capacity=_new_capacity;
  460. }
  461. /*FI]*/
  462. _new_capacity=(C)->_upper/*8*/;
  463. C->_upper=(a1)-(1);
  464. _i=(C)->_upper/*8*/;
  465. while (!((_i)==(_new_capacity))) {
  466. /*[IRF3.5put*/((C)->_storage/*0*/)[_i]=(_elt_default);
  467. /*]*/
  468. _i=(_i)-(1);
  469. }
  470. }
  471. /*FI]*/
  472. }
  473.  
  474.  
  475. T6 r68fast_has(T68* C,T0* a1){
  476. T6 R=0;
  477. R=r68valid_index(C,r68fast_index_of(C,a1));
  478. return R;
  479. }
  480.  
  481.  
  482. void r68make(T68* C,T2 a1){
  483. /*[IF*/
  484. if((a1)==(0)){
  485. C->_upper=-(1);
  486. }
  487.  else if(((C)->_capacity/*4*/)==(0)){
  488. C->_storage=calloc(a1,sizeof(T0*));
  489. C->_capacity=a1;
  490. C->_upper=(a1)-(1);
  491. }
  492.  else if(((C)->_capacity/*4*/)<(a1)){
  493. C->_storage=calloc(a1,sizeof(T0*));
  494. C->_capacity=a1;
  495. C->_upper=(a1)-(1);
  496. }
  497. else{
  498. C->_upper=(a1)-(1);
  499. /*[IRF3.6clear_all*/{T68* C1=C;
  500. T0* __value=NULL;
  501. /*[IRF3.6set_all_with*/{T68* C2=C1;
  502. T0* c1=__value;
  503. r69set_all_with((C2)->_storage/*0*/,c1,(C2)->_upper/*8*/);
  504. }/*]*/
  505. }/*]*/
  506. }
  507. /*FI]*/
  508. }
  509.  
  510.  
  511. T2 r68fast_index_of(T68* C,T0* a1){
  512. T2 R=0;
  513. R=r69fast_index_of((C)->_storage/*0*/,a1,(C)->_upper/*8*/);
  514. return R;
  515. }
  516. /*No:FIXED_ARRAY[STRING].upper*/
  517. /*No:FIXED_ARRAY[STRING].capacity*/
  518. /*No:FIXED_ARRAY[STRING].put*/
  519. /*No:FIXED_ARRAY[STRING].storage*/
  520.  
  521.  
  522. void r83add_last(T83* C,T0* a1){
  523. T2 _new_capacity=0;
  524. /*[IF*/
  525. if(((C)->_capacity/*4*/)<((r83count(C))+(1))){
  526. /*[IF*/
  527. if(((C)->_capacity/*4*/)==(0)){
  528. C->_capacity=16;
  529. C->_storage=calloc((C)->_capacity/*4*/,sizeof(T0*));
  530. }
  531. else{
  532. _new_capacity=(2)*((C)->_capacity/*4*/);
  533. C->_storage=r84realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_new_capacity);
  534. C->_capacity=_new_capacity;
  535. }
  536. /*FI]*/
  537. }
  538. /*FI]*/
  539. C->_upper=((C)->_upper/*8*/)+(1);
  540. /*[IRF3.6put*/{T83* C1=C;
  541. T0* b1=a1;
  542. T2 b2=(C)->_upper/*8*/;
  543. ((C1)->_storage/*0*/)[(b2)-((C1)->_lower/*12*/)]=(b1);
  544. }/*]*/
  545. }
  546.  
  547.  
  548. T0* r83item(T83* C,T2 a1){
  549. T0* R=NULL;
  550. R=((C)->_storage/*0*/)[(a1)-((C)->_lower/*12*/)];
  551. return R;
  552. }
  553.  
  554.  
  555. T0* r83first(T83* C){
  556. T0* R=NULL;
  557. R=r83item(C,(C)->_lower/*12*/);
  558. return R;
  559. }
  560.  
  561.  
  562. T2 r83count(T83* C){
  563. T2 R=0;
  564. R=(((C)->_upper/*8*/)-((C)->_lower/*12*/))+(1);
  565. return R;
  566. }
  567. /*No:ARRAY[PARENT].lower*/
  568. /*No:ARRAY[PARENT].upper*/
  569. /*No:ARRAY[PARENT].capacity*/
  570. /*No:ARRAY[PARENT].put*/
  571. /*No:ARRAY[PARENT].storage*/
  572.  
  573.  
  574. void r73with_capacity(T73* C,T2 a1,T2 a2){
  575. /*[IF*/
  576. if(((C)->_capacity/*4*/)<(a1)){
  577. C->_storage=calloc(a1,sizeof(T0*));
  578. C->_capacity=a1;
  579. }
  580. /*FI]*/
  581. C->_lower=a2;
  582. C->_upper=(a2)-(1);
  583. }
  584.  
  585.  
  586. void r73add_last(T73* C,T0* a1){
  587. T2 _new_capacity=0;
  588. /*[IF*/
  589. if(((C)->_capacity/*4*/)<((r73count(C))+(1))){
  590. /*[IF*/
  591. if(((C)->_capacity/*4*/)==(0)){
  592. C->_capacity=16;
  593. C->_storage=calloc((C)->_capacity/*4*/,sizeof(T0*));
  594. }
  595. else{
  596. _new_capacity=(2)*((C)->_capacity/*4*/);
  597. C->_storage=r69realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_new_capacity);
  598. C->_capacity=_new_capacity;
  599. }
  600. /*FI]*/
  601. }
  602. /*FI]*/
  603. C->_upper=((C)->_upper/*8*/)+(1);
  604. /*[IRF3.6put*/{T73* C1=C;
  605. T0* b1=a1;
  606. T2 b2=(C)->_upper/*8*/;
  607. ((C1)->_storage/*0*/)[(b2)-((C1)->_lower/*12*/)]=(b1);
  608. }/*]*/
  609. }
  610.  
  611.  
  612. T0* r73item(T73* C,T2 a1){
  613. T0* R=NULL;
  614. R=((C)->_storage/*0*/)[(a1)-((C)->_lower/*12*/)];
  615. return R;
  616. }
  617.  
  618.  
  619. T6 r73valid_index(T73* C,T2 a1){
  620. T6 R=0;
  621. R=(((C)->_lower/*12*/)<=(a1))&&((a1)<=((C)->_upper/*8*/));
  622. return R;
  623. }
  624.  
  625.  
  626. T2 r73count(T73* C){
  627. T2 R=0;
  628. R=(((C)->_upper/*8*/)-((C)->_lower/*12*/))+(1);
  629. return R;
  630. }
  631. /*No:ARRAY[STRING].lower*/
  632.  
  633.  
  634. T6 r73fast_has(T73* C,T0* a1){
  635. T6 R=0;
  636. R=r73valid_index(C,r73fast_index_of(C,a1));
  637. return R;
  638. }
  639.  
  640.  
  641. T2 r73fast_index_of(T73* C,T0* a1){
  642. T2 R=0;
  643. R=((C)->_lower/*12*/)+(r69fast_index_of((C)->_storage/*0*/,a1,((C)->_upper/*8*/)-((C)->_lower/*12*/)));
  644. return R;
  645. }
  646. /*No:ARRAY[STRING].upper*/
  647.  
  648.  
  649. T2 r73index_of(T73* C,T0* a1){
  650. T2 R=0;
  651. R=((C)->_lower/*12*/)+(r69index_of((C)->_storage/*0*/,a1,((C)->_upper/*8*/)-((C)->_lower/*12*/)));
  652. return R;
  653. }
  654. /*No:ARRAY[STRING].capacity*/
  655. /*No:ARRAY[STRING].put*/
  656. /*No:ARRAY[STRING].storage*/
  657.  
  658.  
  659. T0* r239twin(T239* C){
  660. T0* R=NULL;
  661. R=malloc(sizeof(*C));
  662. *((T239*)R)=M239;
  663. r239copy(((T239*)R),((T0*)C));
  664. return R;
  665. }
  666.  
  667.  
  668. void r239add_last(T239* C,T0* a1){
  669. T2 _new_capacity=0;
  670. /*[IF*/
  671. if(((C)->_capacity/*4*/)<((r239count(C))+(1))){
  672. /*[IF*/
  673. if(((C)->_capacity/*4*/)==(0)){
  674. C->_capacity=16;
  675. C->_storage=calloc((C)->_capacity/*4*/,sizeof(T0*));
  676. }
  677. else{
  678. _new_capacity=(2)*((C)->_capacity/*4*/);
  679. C->_storage=r240realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_new_capacity);
  680. C->_capacity=_new_capacity;
  681. }
  682. /*FI]*/
  683. }
  684. /*FI]*/
  685. C->_upper=((C)->_upper/*8*/)+(1);
  686. /*[IRF3.6put*/{T239* C1=C;
  687. T0* b1=a1;
  688. T2 b2=(C)->_upper/*8*/;
  689. ((C1)->_storage/*0*/)[(b2)-((C1)->_lower/*12*/)]=(b1);
  690. }/*]*/
  691. }
  692.  
  693.  
  694. T0* r239item(T239* C,T2 a1){
  695. T0* R=NULL;
  696. R=((C)->_storage/*0*/)[(a1)-((C)->_lower/*12*/)];
  697. return R;
  698. }
  699.  
  700.  
  701. T2 r239count(T239* C){
  702. T2 R=0;
  703. R=(((C)->_upper/*8*/)-((C)->_lower/*12*/))+(1);
  704. return R;
  705. }
  706. /*No:ARRAY[E_WHEN].lower*/
  707. /*No:ARRAY[E_WHEN].upper*/
  708.  
  709.  
  710. void r239copy(T239* C,T0* a1){
  711. T2 _needed_capacity=0;
  712. C->_lower=(((T239*)a1))->_lower/*12*/;
  713. C->_upper=(((T239*)a1))->_upper/*8*/;
  714. _needed_capacity=(((C)->_upper/*8*/)-((C)->_lower/*12*/))+(1);
  715. /*[IF*/
  716. if(((C)->_capacity/*4*/)<(_needed_capacity)){
  717. C->_capacity=_needed_capacity;
  718. C->_storage=calloc((C)->_capacity/*4*/,sizeof(T0*));
  719. }
  720. /*FI]*/
  721. /*[IF*/
  722. if((_needed_capacity)>(0)){
  723. r240copy_from((C)->_storage/*0*/,(((T239*)a1))->_storage/*0*/,(_needed_capacity)-(1));
  724. }
  725. /*FI]*/
  726. }
  727. /*No:ARRAY[E_WHEN].capacity*/
  728. /*No:ARRAY[E_WHEN].put*/
  729. /*No:ARRAY[E_WHEN].storage*/
  730.  
  731.  
  732. T0* r232twin(T232* C){
  733. T0* R=NULL;
  734. R=malloc(sizeof(*C));
  735. *((T232*)R)=M232;
  736. r232copy(((T232*)R),((T0*)C));
  737. return R;
  738. }
  739.  
  740.  
  741. void r232add_last(T232* C,T0* a1){
  742. T2 _new_capacity=0;
  743. /*[IF*/
  744. if(((C)->_capacity/*4*/)<((r232count(C))+(1))){
  745. /*[IF*/
  746. if(((C)->_capacity/*4*/)==(0)){
  747. C->_capacity=16;
  748. C->_storage=calloc((C)->_capacity/*4*/,sizeof(T0*));
  749. }
  750. else{
  751. _new_capacity=(2)*((C)->_capacity/*4*/);
  752. C->_storage=r233realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_new_capacity);
  753. C->_capacity=_new_capacity;
  754. }
  755. /*FI]*/
  756. }
  757. /*FI]*/
  758. C->_upper=((C)->_upper/*8*/)+(1);
  759. /*[IRF3.6put*/{T232* C1=C;
  760. T0* b1=a1;
  761. T2 b2=(C)->_upper/*8*/;
  762. ((C1)->_storage/*0*/)[(b2)-((C1)->_lower/*12*/)]=(b1);
  763. }/*]*/
  764. }
  765.  
  766.  
  767. T0* r232item(T232* C,T2 a1){
  768. T0* R=NULL;
  769. R=((C)->_storage/*0*/)[(a1)-((C)->_lower/*12*/)];
  770. return R;
  771. }
  772.  
  773.  
  774. T2 r232count(T232* C){
  775. T2 R=0;
  776. R=(((C)->_upper/*8*/)-((C)->_lower/*12*/))+(1);
  777. return R;
  778. }
  779. /*No:ARRAY[IFTHEN].lower*/
  780. /*No:ARRAY[IFTHEN].upper*/
  781.  
  782.  
  783. void r232copy(T232* C,T0* a1){
  784. T2 _needed_capacity=0;
  785. C->_lower=(((T232*)a1))->_lower/*12*/;
  786. C->_upper=(((T232*)a1))->_upper/*8*/;
  787. _needed_capacity=(((C)->_upper/*8*/)-((C)->_lower/*12*/))+(1);
  788. /*[IF*/
  789. if(((C)->_capacity/*4*/)<(_needed_capacity)){
  790. C->_capacity=_needed_capacity;
  791. C->_storage=calloc((C)->_capacity/*4*/,sizeof(T0*));
  792. }
  793. /*FI]*/
  794. /*[IF*/
  795. if((_needed_capacity)>(0)){
  796. r233copy_from((C)->_storage/*0*/,(((T232*)a1))->_storage/*0*/,(_needed_capacity)-(1));
  797. }
  798. /*FI]*/
  799. }
  800. /*No:ARRAY[IFTHEN].capacity*/
  801. /*No:ARRAY[IFTHEN].put*/
  802. /*No:ARRAY[IFTHEN].storage*/
  803. /*No:ARRAY[E_REQUIRE].clear_all*/
  804.  
  805.  
  806. void r365add_last(T365* C,T0* a1){
  807. T2 _new_capacity=0;
  808. /*[IF*/
  809. if(((C)->_capacity/*4*/)<((r365count(C))+(1))){
  810. /*[IF*/
  811. if(((C)->_capacity/*4*/)==(0)){
  812. C->_capacity=16;
  813. C->_storage=calloc((C)->_capacity/*4*/,sizeof(T0*));
  814. }
  815. else{
  816. _new_capacity=(2)*((C)->_capacity/*4*/);
  817. C->_storage=r366realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_new_capacity);
  818. C->_capacity=_new_capacity;
  819. }
  820. /*FI]*/
  821. }
  822. /*FI]*/
  823. C->_upper=((C)->_upper/*8*/)+(1);
  824. /*[IRF3.6put*/{T365* C1=C;
  825. T0* b1=a1;
  826. T2 b2=(C)->_upper/*8*/;
  827. ((C1)->_storage/*0*/)[(b2)-((C1)->_lower/*12*/)]=(b1);
  828. }/*]*/
  829. }
  830.  
  831.  
  832. T0* r365item(T365* C,T2 a1){
  833. T0* R=NULL;
  834. R=((C)->_storage/*0*/)[(a1)-((C)->_lower/*12*/)];
  835. return R;
  836. }
  837. /*No:ARRAY[E_REQUIRE].set_all_with*/
  838.  
  839.  
  840. T6 r365valid_index(T365* C,T2 a1){
  841. T6 R=0;
  842. R=(((C)->_lower/*12*/)<=(a1))&&((a1)<=((C)->_upper/*8*/));
  843. return R;
  844. }
  845.  
  846.  
  847. T0* r365first(T365* C){
  848. T0* R=NULL;
  849. R=r365item(C,(C)->_lower/*12*/);
  850. return R;
  851. }
  852.  
  853.  
  854. T2 r365count(T365* C){
  855. T2 R=0;
  856. R=(((C)->_upper/*8*/)-((C)->_lower/*12*/))+(1);
  857. return R;
  858. }
  859. /*No:ARRAY[E_REQUIRE].lower*/
  860.  
  861.  
  862. T6 r365fast_has(T365* C,T0* a1){
  863. T6 R=0;
  864. R=r365valid_index(C,r365fast_index_of(C,a1));
  865. return R;
  866. }
  867.  
  868.  
  869. void r365make(T365* C,T2 a1,T2 a2){
  870. T2 _needed=0;
  871. C->_lower=a1;
  872. C->_upper=a2;
  873. _needed=((a2)-(a1))+(1);
  874. /*[IF*/
  875. if((_needed)>(0)){
  876. /*[IF*/
  877. if(((C)->_capacity/*4*/)<(_needed)){
  878. C->_storage=calloc(_needed,sizeof(T0*));
  879. C->_capacity=_needed;
  880. }
  881. else{
  882. /*[IRF3.6clear_all*/{T365* C1=C;
  883. T0* __value=NULL;
  884. /*[IRF3.6set_all_with*/{T365* C2=C1;
  885. T0* c1=__value;
  886. r366set_all_with((C2)->_storage/*0*/,c1,((C2)->_upper/*8*/)-((C2)->_lower/*12*/));
  887. }/*]*/
  888. }/*]*/
  889. }
  890. /*FI]*/
  891. }
  892. /*FI]*/
  893. }
  894.  
  895.  
  896. T2 r365fast_index_of(T365* C,T0* a1){
  897. T2 R=0;
  898. R=((C)->_lower/*12*/)+(r366fast_index_of((C)->_storage/*0*/,a1,((C)->_upper/*8*/)-((C)->_lower/*12*/)));
  899. return R;
  900. }
  901. /*No:ARRAY[E_REQUIRE].upper*/
  902.  
  903.  
  904. void r365clear(T365* C){
  905. C->_upper=((C)->_lower/*12*/)-(1);
  906. }
  907.  
  908.  
  909. T6 r365empty(T365* C){
  910. T6 R=0;
  911. R=(r365count(C))==(0);
  912. return R;
  913. }
  914. /*No:ARRAY[E_REQUIRE].capacity*/
  915. /*No:ARRAY[E_REQUIRE].put*/
  916. /*No:ARRAY[E_REQUIRE].storage*/
  917.  
  918.